#include <stdio.h>
    #include <ctype.h>
    #include <unistd.h>
    #include <sys/time.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <string.h>


    #define NUM 5 //资源数
    pthread_t thread[5];
    pthread_mutex_t mut; //互斥信号量
    struct zy {
    char type; //资源的名称
    int n; //资源的数量
    };
    struct jc {
    char name; //名称
    int runtime; //执行时间
    int waittime; //等待时间
    int typenum; //进程所申请的资源数
    struct zy r[5]; //所申请资源的信息
    };
    struct y {
    int flag; //标志，0：未出现过的资源，（进程a申请资源B 1个资源B 1个）1：该资源已申请
    int index; //资源下标
    int tr; //进程的下标
    int flag1; //1：该资源不能再申请；0：该资源还可以申请
    } Y[10][NUM];
    struct jc JC[5];
    struct zy ZY[NUM]; //每种资源的名称及数量
    int u = 0; //进程数
    int a = 0; //资源数
    int Available[NUM]; //可使用资源向量
    int Max[10][NUM]; //最大需求矩阵
    int Allocation[10][NUM]; //分配矩阵
    int Need[10][NUM]; //需求矩阵
    int Work[NUM]; //工作向量
    int Finish[NUM]; //状态标志
    int Request[10][NUM]; //进程申请资源向量
    //对银行家算法中的需求矩阵进行初始化
    int init() {
    int i, j, x;
    for (i = 0; i < u; i++) {
    for (j = 0; j < a; j++) {
    Need[i][j] = Max[i][j] - Allocation[i][j];
    }
    }
    return 0;
    }
    //输入资源信息
    int ziyuan()
    {
    int i,x;
    printf("************************************************\n");
    printf("请输入资源的种类数：\n");
    fflush(stdin);
    x=scanf("%d",&a);
    while(x==0)
    {
    printf("不符合规则，请重新输入！\n");
    fflush(stdin);
    x=scanf("%d",&a);
    }
    for(i=0;i<a;i++)
    {
    printf("请输入第%d种资源的名称(A---Z)：\n",i);
    scanf("%c",&ZY[i].type);
    while(ZY[i].type=='\n')scanf("%c",&ZY[i].type);
    while(!isupper(ZY[i].type))
    {
    printf("不符合规则，请重新输入！\n");
    scanf("%c",&ZY[i].type);
    while(ZY[i].type=='\n')scanf("%c",&ZY[i].type);
    }
    printf("请输入资源%c的数量：",ZY[i].type);
    fflush(stdin);
    x=scanf("%d",&ZY[i].n);
    while(x==0)
    {
    printf("不符合规则，请重新输入！\n");
    fflush(stdin);
    x=scanf("%d",&ZY[i].n);
    }
    Available[i]=ZY[i].n;//对可使用资源向量进行初始化
    }
    return 0;
    }
    //对整个二维数组Y进行遍历
    int judge_pro(int m, int p[10]) {
    int i, j;
    for (i = 0; i < m; i++) {
    for (j = 0; j < p[i]; j++) {
    if (!(Y[i][j].flag1)) {
    return 1;
    } //只要有1个进程的1种资源未申请完，则返回1
    }
    }
    return 0; //仅当所有进程对资源的申请都达到所需量时才返回0
    }
    //对二维数组中的某一行（对应某种进程）进行遍历
    int panduan1(int tr, int p[10]) {
    int i;
    for (i = 0; i < p[tr]; i++) {
    if (!(Y[tr][i].flag1))
    return 0; //该进程只要有1个资源未申请完，则返回0
    }
    return 1; //仅当该进程所有资源都申请完时返回1
    }
    //产生随机进程和进程所申请的资源，并调用银行家算法
    int ra() {
    int col[10];
    int i, j, k = 0, w = 0, m = 0, n = 0, q = 0; //k记录最大需求矩阵中数目不为0的元素个数
    printf("\n");
    if (u == 0 || a == 0) {
    printf("请先输入信息！\n");
    return 0;
    }
    //对Max数组进行遍历，筛选并记录各进程对所有资源的最大申请量大于0的元素信息
    for (i = 0; i < u; i++) {
    for (j = 0; j < a; j++) {
    if (Max[i][j]) {
    Y[m][n].index = j; //index记录资源下标
    Y[m][n].tr = i; //tr记录进程下标
    Y[m][n].flag = 0; //flag=1：所记录的资源已申请过，flag=0:所记录的资源尚未申请
    Y[m][n].flag1 = 0; //flag1=1：进程对该资源的申请已达到所需量，flag=0:还未达到所需量
    n++;
    }
    }
    col[m] = n; //数组col记录二维数组Y的每一行的列数
    n = 0; //对n进行恢复，以便下次循环
    m++;
    }
    //只要有资源未申请完就执行循环
    while (judge_pro(m, col)) {
    int _one = 0;
    int tr;
    //若该进程所有资源都申请完，则执行循环
    do {
    tr = rand() % m;
    } while (panduan1(tr, col)); //

    printf("%c进程申请\n", JC[Y[tr][0].tr].name);

    int x = col[tr];
    //若有资源申请完，则使x减1
    for (i = 0; i < col[tr]; i++) { //处理函数.
    if (Y[tr][i].flag1)
    x--;
    }
    //用x保证循环次数，使该进程随机产生对各资源的申请量
    for (i = 0; i < x; i++) {
    //该进程对当前资源
    do {

    j = rand() % (col[tr]); //j表示Y[][]的第tr行的资源下标
    while (_one == j) {
    j = rand() % (col[tr]); //j表示Y[][]的第tr行的资源下标
    }
    _one = j;

    } while (Y[tr][j].flag && Y[tr][j].flag1);
    /*
    flag=0;flag1=0代表当前资源既没申请过也没申请完
    flag=1;flag1=0代表当前资源已申请过，但没申请完
    flag=0;flag1=1代表当前资源没申请过，但申请完（不存在这种可能）



    flag=1;flag1=1代表当前资源已申请过，同时申请完
    */
    Y[tr][j].flag = 1; //改进程的当前资源标志为已申请过
    printf("%c资源", ZY[Y[tr][j].index].type);
    w = 1
    + rand()
    % (Max[tr][Y[tr][j].index]
    - Allocation[tr][Y[tr][j].index]);
    printf("%d个", w);
    Request[Y[tr][0].tr][Y[tr][j].index] = w; //将申请的资源信息赋给Request数组
    }
    printf("\n");
    request(Y[tr][0].tr, col[tr], tr); //调用银行家算法
    if (panduan1(tr, col)) {
    printf("进程%c已执行完毕！", JC[Y[tr][0].tr].name);
    }
    }
    //所有进程执行完成后，对资源数目进行恢复
    if (!(judge_pro(m, col))) {
    for (i = 0; i < a; i++) {
    Allocation[j][i] = 0;
    Need[j][i] = Max[j][i] - Allocation[j][i];
    }
    }
    return 0;
    }
    //进程的信息
    int jincheng()
    {
    int i=0;
    int j,g,x;
    char name;
    printf("请输入进程的个数：\n");
    fflush(stdin);
    x=scanf("%d",&u);
    while(x==0)
    {
    printf("不符合规则，请重新输入！\n");
    fflush(stdin);
    x=scanf("%d",&u);
    }
    for(i=0;i<u;i++)
    {
    printf("请输入第%d种进程的名称：\n",i);
    scanf("%c",&JC[i].name);
    while(JC[i].name=='\n')scanf("%c",&JC[i].name);
    for(g=0;g<a;g++)
    {
    JC[i].r[g].type=ZY[g].type;
    }
    for(j=0;j<a;j++)
    {
    printf("请输入进程%c对资源%c的最大申请量：",JC[i].name,JC[i].r[j].type);
    fflush(stdin);
    x=scanf("%d",&Max[i][j]);
    while(x==0)
    {
    printf("不符合规则，请重新输入！\n");
    fflush(stdin);
    x=scanf("%d",&Max[i][j]);
    }
    while(Max[i][j]>ZY[j].n)
    {
    printf("进程%c对资源%c的最大申请量大于资源%c的数量，请重新输入：",JC[i].name,JC[i].r[j].type,JC[i].r	[j].type);
    fflush(stdin);
    x=scanf("%d",&Max[i][j]);
    while(x==0)
    {
    printf("不符合规则，请重新输入！\n");
    fflush(stdin);
    x=scanf("%d",&Max[i][j]);
    }
    }
    }
    }
    init();
    return 0;
    }
    //输入进程和进程所申请的资源，并调用银行家算法
    int shuru() {
    int i, j, t = -1;
    char name;
    if (u == 0 || a == 0) {
    printf("请先输入信息！\n");
    return 0;
    }
    printf("请输入需申请资源的进程：\n");
    scanf("%c", &name);
    while (name == '\n')
    scanf("%c", &name);
    for (i = 0; i < u; i++) {
    if (JC[i].name == name)
    t = i;
    }
    while (t == -1) {
    printf("不存在该进程，请重新输入！：\n");
    scanf("%c", &name);
    while (name == '\n')
    scanf("%c", &name);
    for (i = 0; i < u; i++) {
    if (JC[i].name == name)
    t = i;
    }
    }
    for (i = 0; i < u; i++) {
    for (j = 0; j < a; j++) {
    printf("进程%c对资源%c的已分配量：", JC[i].name, ZY[j].type);
    scanf("%d", &Allocation[i][j]);
    Need[i][j] = Max[i][j] - Allocation[i][j];
    Available[j] -= Allocation[i][j];
    }
    }
    for (j = 0; j < a; j++) {
    printf("进程%c对资源%c的申请量：", JC[t].name, ZY[j].type);
    scanf("%d", &Request[t][j]);
    }
    request(t, -1, -1);
    }
    //输出进程信息，在进程并发中调用
    int print() {
    int g, j, i;
    printf(
    "\n\n  *******************************************************************");
    printf("\n  *                       当前的进程状态                            *");
    if (u == 0) {// u:进程的数目(几个进程)
    printf("您尚未输入信息！");
    return 0;
    } else {
    printf("\n  *      进程名称     等待时间      执行时间          申请资源信息  *");
    for (g = 0; g < u; g++) {
    printf(
    "\n  *       %c            %d             %d          ",
    JC[g].name, JC[g].waittime, JC[g].runtime);
    for (j = 0; j < a; j++) {
    printf("%d(%c) ", Max[g][j], ZY[j].type);
    }
    printf("     *");
    }
    printf(
    "\n  *******************************************************************\n");
    return 1;
    }
    }
    //输出信息，在银行家算法中调用
    void print1() {
    int i, j;
    printf(
    "\n\n  ********************************************************************");
    printf("\n  *                        当前的系统状态                            *");
    printf("\n  *      进程名称     目前占有量      最大需求量           尚需要量  *\n");
    for (i = 0; i < u; i++) {
    printf("  *         %c         ", JC[i].name);
    for (j = 0; j < a; j++) {
    printf("%d(%c) ", Allocation[i][j], ZY[j].type);
    }
    printf("     ");
    for (j = 0; j < a; j++) {
    printf("%d(%c) ", Max[i][j], ZY[j].type);
    }
    printf("        ");
    for (j = 0; j < a; j++) {
    printf("%d(%c) ", Need[i][j], ZY[j].type);
    }
    printf("*\n");
    }
    printf(
    "  ********************************************************************");
    printf("\n\n系统剩余资源量：   ");
    for (i = 0; i < a; i++) {
    printf("   %d(%c) ", Available[i], ZY[i].type);
    }
    printf("\n");
    }
    //进程申请，银行家算法
    int request(int tr, int z, int r) //进程提出新申请的代码部分
    {
    int p = 0, q = 0, i, j, f = 0, b, l, t = 0, k = 0; //g记录进程序号
    if (u == 0 || a == 0) {
    printf("请先输入信息！\n");
    return 0;
    } else {
    for (i = 0; i < a; i++) {
    if (Request[tr][i] > Need[tr][i])
    p++;
    if (Request[tr][i] > Available[i])
    q++;
    }
    if (p) {
    printf("\n出错！进程申请的资源数多于它自己申报的最大量\n");
    print1();
    if (z != -1) //手动输入时不执行
    {
    for (i = 0; i < a; i++) {
    if (Need[tr][i] == 0) {
    for (t = 0; t < z; t++) {
    if (Y[r][t].index == i)
    Y[r][t].flag1 = 1;
    }
    }
    }
    }
    for (i = 0; i < a; i++) {
    Available[i] = ZY[i].n;
    }
    return 0;
    } else if (q) {
    printf("\n进程%c必须等待\n", JC[tr].name);
    print1();
    if (z != -1) {
    for (i = 0; i < a; i++) {
    if (Need[tr][i] == 0) {
    for (t = 0; t < z; t++) {
    if (Y[r][t].index == i)
    Y[r][t].flag1 = 1;
    }
    }
    }
    }
    for (i = 0; i < a; i++) {
    Available[i] = ZY[i].n;
    }
    return 0;
    } else {
    for (j = 0; j < a; j++) { //以下是预分配Work
    Available[j] = Available[j] - Request[tr][j];
    Allocation[tr][j] = Allocation[tr][j] + Request[tr][j];
    Need[tr][j] = Need[tr][j] - Request[tr][j];
    Work[j] = Available[j];
    }
    for (i = 0; i < a; i++) {
    Work[i] = Available[i]; //Work[i]只是一个暂时寄存的中间变量，为防止在下面
    //安全性检查时修改到Available[i]而代替的一维数组
    Finish[i] = 0;
    }



    for (k = 0; k < u; k++) {
    for (i = 0; i < u; i++) {
    b = 0; //计数器初始化,记录进程中满足条件的资源数
    for (j = 0; j < a; j++) {
    if (Need[i][j] <= Work[j]) {
    b = b + 1;
    }
    if (Finish[i] == 0 && b == a) {
    for (l = 0; l < a; l++) {
    Work[l] = Work[l] + Allocation[i][l];
    }
    Finish[i] = 1;
    printf("$$ %c ", JC[i].name); //依次输出进程安全序列之一中每个元素
    }
    }
    }
    }
    printf("\n");
    for (i = 0; i < u; i++) {
    if (Finish[i] == 1) {
    f = f + 1;
    } //统计Finish[i]＝＝1的个数
    }
    if (f == u) {
    printf("安全性算法检查预分配后系统处于安全状态，以上为安全序列！可以将资源分配给进程%c", JC[tr].name);
    f = 0; //将计数器f重新初始化，为下一次提出新的进程申请做准备
    print1();
    if (z != -1) {
    for (i = 0; i < a; i++) {
    Request[tr][i] = 0;
    if (Need[tr][i] == 0) {
    for (t = 0; t < z; t++) {
    if (Y[r][t].index == i)
    Y[r][t].flag1 = 1;
    }
    }
    Available[i] = ZY[i].n;
    }
    }
    for (i = 0; i < a; i++) {
    Available[i] = ZY[i].n;
    }
    } else {
    printf("安全性算法检查预分配后系统处于不安全状态，不能进行分配！"); //以下代码为当系统被判定为不安全状态时
    //返回提出申请前的状态
    for (i = 0; i < a; i++) {
    Available[i] = Available[i] + Request[tr][i];
    Allocation[tr][i] = Allocation[tr][i] - Request[tr][i];
    Need[tr][i] = Need[tr][i] + Request[tr][i];
    }
    print1();
    }
    return 1;
    }
    }
    }
    void *thread1()
    {
    int i,j;
    int tr=0;



    loop:for(i=0;i<a;i++)
    {
    if(Max[tr][i]>ZY[i].n)
    {
    printf("进程%c所申请的%c资源数目大于现有的%c资源数目！,不能进行分配\n",JC[tr].name,ZY[i].type,ZY[i].type);
    printf("睡眠%d秒\n",JC[tr].waittime);
    sleep(JC[tr].waittime);
    //线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。
    goto loop;
    break;
    }
    }
    pthread_mutex_lock(&mut);//声明开始用互斥锁上锁

    //a表示资源种类数
    //结构体二维数组ZY存放资源数目
    //二维数组Max存放进程申请资源的数目
    for(i=0;i<a;i++)
    {
    ZY[i].n-=Max[tr][i];
    }
    printf("进程%c",JC[tr].name);
    for(i=0;i<a;i++)
    {
    printf("申请%c资源%d个",ZY[i].type,Max[tr][i]);
    }
    printf("成功\n");
    printf("系统剩余资源个数：");
    for(i=0;i<a;i++)
    {
    printf("%c(%d个) ",ZY[i].type,ZY[i].n);
    }
    printf("\n");
    pthread_mutex_unlock(&mut);//互斥锁到此结束
    //2.执行当前进程
    printf("进程%c正在执行.....\n",JC[tr].name);
    sleep(JC[tr].runtime);
    printf("进程%c执行完成\n",JC[tr].name);
    //3.利用互斥信号量对资源数目进行恢复
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    ZY[i].n+=Max[tr][i];
    }
    pthread_mutex_unlock(&mut);
    }

    void *thread2()
    {
    int i,j;
    int tr=1;
    //1.利用互斥信号量对资源数目进行更新
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    if(Max[tr][i]>ZY[i].n)
    {
    printf("进程%c所申请的%c资源数目大于现有的%c资源数目！,不能进行分配\n",JC[tr].name,ZY[i].type,ZY[i].type);
    printf("睡眠%d秒\n",JC[tr].waittime);
    sleep(JC[tr].waittime);
    //线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。
    //  goto loop;
    break;
    }
    }
    for(i=0;i<a;i++)
    {
    ZY[i].n-=Max[tr][i];
    }
    printf("进程%c",JC[tr].name);
    for(i=0;i<a;i++)
    {
    printf("申请%c资源%d个",ZY[i].type,Max[tr][i]);
    }
    printf("成功\n");
    printf("系统剩余资源个数：");
    for(i=0;i<a;i++)
    {
    printf("%c(%d个) ",ZY[i].type,ZY[i].n);
    }
    printf("\n");
    pthread_mutex_unlock(&mut);
    //3.执行当前进程
    printf("进程%c正在执行.....\n",JC[tr].name);
    sleep(JC[tr].runtime);
    printf("进程%c执行完成\n",JC[tr].name);
    //4.利用互斥信号量对资源数目进行恢复
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    ZY[i].n+=Max[tr][i];
    }
    pthread_mutex_unlock(&mut);
    }
    void *thread3()
    {
    int i,j;
    int tr=2;



    loop:for(i=0;i<a;i++)
    {
    if(Max[tr][i]>ZY[i].n)
    {
    printf("进程%c所申请的%c资源数目大于现有的%c资源数目！,不能进行分配\n",JC[tr].name,ZY[i].type,ZY[i].type);
    printf("睡眠%d秒\n",JC[tr].waittime);
    sleep(JC[tr].waittime+2);
    //线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。
    goto loop;
    break;
    }
    }
    pthread_mutex_lock(&mut);//声明开始用互斥锁上锁

    //a表示资源种类数
    //结构体二维数组ZY存放资源数目
    //二维数组Max存放进程申请资源的数目
    for(i=0;i<a;i++)
    {
    ZY[i].n-=Max[tr][i];
    }
    printf("进程%c",JC[tr].name);
    for(i=0;i<a;i++)
    {
    printf("申请%c资源%d个",ZY[i].type,Max[tr][i]);
    }
    printf("成功\n");
    printf("系统剩余资源个数：");
    for(i=0;i<a;i++)
    {
    printf("%c(%d个) ",ZY[i].type,ZY[i].n);
    }
    printf("\n");
    pthread_mutex_unlock(&mut);//互斥锁到此结束
    //2.执行当前进程
    printf("进程%c正在执行.....\n",JC[tr].name);
    sleep(JC[tr].runtime);
    printf("进程%c执行完成\n",JC[tr].name);
    //3.利用互斥信号量对资源数目进行恢复
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    ZY[i].n+=Max[tr][i];
    }
    pthread_mutex_unlock(&mut);
    }
    void *thread4()
    {
    int i,j;
    int tr=3;



    loop:for(i=0;i<a;i++)
    {
    if(Max[tr][i]>ZY[i].n)
    {
    printf("进程%c所申请的%c资源数目大于现有的%c资源数目！,不能进行分配\n",JC[tr].name,ZY[i].type,ZY[i].type);
    printf("睡眠%d秒\n",JC[tr].waittime);
    sleep(JC[tr].waittime+2);
    //线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。
    goto loop;
    break;
    }
    }
    pthread_mutex_lock(&mut);//声明开始用互斥锁上锁

    //a表示资源种类数
    //结构体二维数组ZY存放资源数目
    //二维数组Max存放进程申请资源的数目
    for(i=0;i<a;i++)
    {
    ZY[i].n-=Max[tr][i];
    }
    printf("进程%c",JC[tr].name);
    for(i=0;i<a;i++)
    {
    printf("申请%c资源%d个",ZY[i].type,Max[tr][i]);
    }
    printf("成功\n");
    printf("系统剩余资源个数：");
    for(i=0;i<a;i++)
    {
    printf("%c(%d个) ",ZY[i].type,ZY[i].n);
    }
    printf("\n");
    pthread_mutex_unlock(&mut);//互斥锁到此结束
    //2.执行当前进程
    printf("进程%c正在执行.....\n",JC[tr].name);
    sleep(JC[tr].runtime);
    printf("进程%c执行完成\n",JC[tr].name);
    //3.利用互斥信号量对资源数目进行恢复
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    ZY[i].n+=Max[tr][i];
    }
    pthread_mutex_unlock(&mut);
    }
    void *thread5()
    {
    int i,j;
    int tr=4;



    loop:for(i=0;i<a;i++)
    {
    if(Max[tr][i]>ZY[i].n)
    {
    printf("进程%c所申请的%c资源数目大于现有的%c资源数目！,不能进行分配\n",JC[tr].name,ZY[i].type,ZY[i].type);
    printf("睡眠%d秒\n",JC[tr].waittime);
    sleep(JC[tr].waittime+2);
    //线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。
    goto loop;
    break;
    }
    }
    pthread_mutex_lock(&mut);//声明开始用互斥锁上锁

    //a表示资源种类数
    //结构体二维数组ZY存放资源数目
    //二维数组Max存放进程申请资源的数目
    for(i=0;i<a;i++)
    {
    ZY[i].n-=Max[tr][i];
    }
    printf("进程%c",JC[tr].name);
    for(i=0;i<a;i++)
    {
    printf("申请%c资源%d个",ZY[i].type,Max[tr][i]);
    }
    printf("成功\n");
    printf("系统剩余资源个数：");
    for(i=0;i<a;i++)
    {
    printf("%c(%d个) ",ZY[i].type,ZY[i].n);
    }
    printf("\n");
    pthread_mutex_unlock(&mut);//互斥锁到此结束
    //2.执行当前进程
    printf("进程%c正在执行.....\n",JC[tr].name);
    sleep(JC[tr].runtime);
    printf("进程%c执行完成\n",JC[tr].name);
    //3.利用互斥信号量对资源数目进行恢复
    pthread_mutex_lock(&mut);
    for(i=0;i<a;i++)
    {
    ZY[i].n+=Max[tr][i];
    }
    pthread_mutex_unlock(&mut);
    }

    void thread_create()//创建线程
    {
    int temp,i;
    memset(&thread, 0, sizeof(thread));//为线程分配内存空间
    /*创建线程*/

    if((temp = pthread_create(&thread[0], NULL, thread1,NULL)) != 0)
    //第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
    //当创建线程成功时，函数返回0，若不为0则说明创建线程失败
    printf("进程%c创建失败!\n",JC[0].name);
    else
    printf("进程%c被创建\n",JC[0].name);
    if((temp = pthread_create(&thread[1], NULL, thread2,NULL)) != 0)
    //第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
    //当创建线程成功时，函数返回0，若不为0则说明创建线程失败
    printf("进程%c创建失败!\n",JC[1].name);
    else
    printf("进程%c被创建\n",JC[1].name);
    if((temp = pthread_create(&thread[2], NULL, thread3,NULL)) != 0)
    //第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
    //当创建线程成功时，函数返回0，若不为0则说明创建线程失败
    printf("进程%c创建失败!\n",JC[2].name);
    else
    printf("进程%c被创建\n",JC[2].name);
    if((temp = pthread_create(&thread[3], NULL, thread4,NULL)) != 0)
    //第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
    //当创建线程成功时，函数返回0，若不为0则说明创建线程失败
    printf("进程%c创建失败!\n",JC[3].name);
    else
    printf("进程%c被创建\n",JC[3].name);
    if((temp = pthread_create(&thread[4], NULL, thread5,NULL)) != 0)
    //第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
    //当创建线程成功时，函数返回0，若不为0则说明创建线程失败
    printf("进程%c创建失败!\n",JC[4].name);
    else
    printf("进程%c被创建\n",JC[4].name);

    }

    void thread_wait(void)
    {
    /*等待线程结束*/
    int i;
    for(i=0;i<5;i++){
    if(thread[i] !=0)
    {
    pthread_join(thread[i],NULL);
    }
    }
    }
    int sig()
    {
    int i,min=0,j,q,t=-1,m=0,x,n,g;
    char name;
    if(u==0||a==0)//没有初始化进程和资源的相关信息 u表示进程数 a表示资源数
    {
    printf("请先输入信息！\n"); return 0;
    }
    else
    {
    for(i=0;i<u;i++)
    {
    printf("请输入进程%c的申请资源的等待时间：\n",JC[i].name);
    scanf("%d",&JC[i].waittime);
    printf("请输入进程%c的执行时间（以秒为单位）：\n",JC[i].name);
    scanf("%d",&JC[i].runtime);
    }
    print();
    pthread_mutex_init(&mut,NULL);/*用默认属性初始化互斥锁 NULL参数表明使用默认属性    互斥锁用来保证一段时间内只有一个线程在执行一段代码。*/
    thread_create();
    thread_wait();
    //print();
    return 1;
    }
    }
    int  main(){
    int h=1,k,s;
    while(h)
    {
    printf("\n\n  *******************************************************************");
    printf("\n  *                      ★ 欢迎使用本程序 ★                         *");
    printf("\n  *     1:………………………………………输入进程及资源信息                         *");
    printf("\n  *     2:………………………………………使用信号量解决进程互斥                     *");
    printf("\n  *     3:………………………………………银行家算法                                 *");
    printf("\n  *     4:………………………………………退出程序                                   *");
    printf("\n  *******************************************************************");
    printf("\n\n 请选择： ");
    scanf("%d",&k);
    switch(k)
    {
    case 1:ziyuan(); jincheng();     break;
    case 2:sig(); break;
    case 3:
    {
    printf("\n\n  *******************************************************************");
    printf("\n  *1:…………………………………………… 随机输出                                     *");
    printf("\n  *2:…………………………………………………  手动输入                                  *");
    printf("\n  *******************************************************************");
    printf("\n\n 请选择： ");
    scanf("%d",&s);
    switch(s)
    {
    case 1:ra();h=1; break;
    case 2:shuru(); h=1;break;
    }
    }break;
    case 4:h=0;        break;
    }
    printf("\n");
    }
    printf("\n\n       谢谢使用 \n");
    printf("\n\n  See you next time!!!\n\n\n");
    return 0;
    }

